package org.lboot.flow.module.define.validator;

import cn.hutool.core.lang.Validator;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.lboot.core.exception.BusinessException;
import org.lboot.flow.constant.FlowNodeTypeConst;
import org.lboot.flow.model.FlowModel;
import org.lboot.flow.model.node.BaseModel;
import org.lboot.flow.model.node.DecisionTaskModel;
import org.lboot.flow.model.node.ExclusiveGatewayModel;
import org.lboot.flow.model.node.ParallelGatewayModel;
import org.lboot.flow.parser.FlowNodeParser;
import org.lboot.flow.utils.FlowModelUtil;
import org.springframework.http.HttpStatus;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Deprecated
@Slf4j
//注解实现类
public class FlowJsonValidator implements ConstraintValidator<FlowJson, String> {

    /**
     * 校验是否包含后继节点
     * @param model
     */
    public void hasNext(BaseModel model){
        if (Validator.isEmpty(model.getNextNodeId())){
            throw new BusinessException(HttpStatus.BAD_REQUEST,model.getNodeType()+"节点必须指定后续节点");
        }
    }

    @Override
    public void initialize(FlowJson constraintAnnotation) {
        ConstraintValidator.super.initialize(constraintAnnotation);
    }

    @Override
    @SneakyThrows
    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {

//        FlowNodeParser flowNodeParser = new FlowNodeParser();
//        // 解析ERROR
//        FlowModel flowModel = flowNodeParser.parser(s);
//        if (Validator.isEmpty(flowModel)){
//
//            return false;
//        }
//        Set<String> nodeIdSet = new HashSet<>();
//        // 获取流程节点列表
//        List<BaseModel> models = flowModel.getNodeList();
//        // 定义全部nodeId列表
//        List<String> nodeIds = models.stream().map(BaseModel::getId).collect(Collectors.toList());
//        for (BaseModel model:models){
//            nodeIdSet.add(model.getId());
//            // 校验节点类型
//            if (!FlowModelUtil.validNodeType(model.getNodeType())){
//                throw new BusinessException(HttpStatus.BAD_REQUEST,"错误的节点类型"+model.getNodeType());
//            }
//            String nodeType = model.getNodeType();
//            // 分类校验
//            if (nodeType.equals(FlowNodeTypeConst.START_NODE)){
//                // 开始节点
//                hasNext(model);
//            }
//            else if (nodeType.equals(FlowNodeTypeConst.TASK_NODE)){
//                // TASK节点
//                hasNext(model);
//            }
//            else if (nodeType.equals(FlowNodeTypeConst.PARALLEL_GATEWAY_NODE)){
//                // 并行网关节点
//                ParallelGatewayModel gatewayModel = (ParallelGatewayModel) model;
//                if (gatewayModel.getStrategy().equals("join") || gatewayModel.getStrategy().equals("fork")){
//                    log.info("并行网关{}策略为{}",gatewayModel.getId(),gatewayModel.getStrategy());
//                }else {
//                    throw new BusinessException(HttpStatus.BAD_REQUEST,"并行网关策略只支持fork/join");
//                }
//                if (gatewayModel.getNodeIds().isEmpty()){
//                    throw new BusinessException(HttpStatus.BAD_REQUEST,"并行网关节点列表不可为空");
//                }
//                // 节点必须全都包含
//                if (!new HashSet<>(nodeIds).containsAll(gatewayModel.getNodeIds())){
//                    throw new BusinessException(HttpStatus.BAD_REQUEST,"并行网关中存在不可达节点");
//                }
//            }
//            else if (nodeType.equals(FlowNodeTypeConst.EXCLUSIVE_GATEWAY_NODE)){
//                // 排他网关节点
//                ExclusiveGatewayModel gatewayModel = (ExclusiveGatewayModel) model;
//                if (Validator.isEmpty(gatewayModel.getDecisionMaker())){
//                    throw new BusinessException(HttpStatus.BAD_REQUEST,"排他网关节点决策器不可为空");
//                }
//                if (gatewayModel.getNodeIds().isEmpty()){
//                    throw new BusinessException(HttpStatus.BAD_REQUEST,"排他网关节点列表不可为空");
//                }
//                // 节点必须全都包含
//                if (!new HashSet<>(nodeIds).containsAll(gatewayModel.getNodeIds())){
//                    throw new BusinessException(HttpStatus.BAD_REQUEST,"排他网关中存在不可达节点");
//                }
//            }
//            else if (nodeType.equals(FlowNodeTypeConst.DECISION_TASK_NODE)){
//                // 用户决策节点
//                DecisionTaskModel taskModel = (DecisionTaskModel) model;
//                if (taskModel.getNodeIds().isEmpty()){
//                    throw new BusinessException(HttpStatus.BAD_REQUEST,"决策TASK节点列表不可为空");
//                }
//            }
//
//
//        }
//        // 存在重名
//        if (models.size() != nodeIdSet.size()){
//            throw new BusinessException(HttpStatus.BAD_REQUEST,"存在ID重复流程节点");
//        }
//        // 存在无连接流程节点
//        // 孤儿节点判断 @TODO
//
//        // 遍历流程节点
//        return true;
        return true;
    }
}
